package com.jc.nio.thread;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.StringTokenizer;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

import com.jc.nio.process.Processor;

/**
 * worker处理类<br/>
 * 处理任务的worker，它本身是一个处理线程Runnable，每个worker都有一个selector，对注册到该通道的selector进行处理，
 * 已到达负载均衡的效果
 * 
 * @author Joeson
 * @since 2014/05
 * @version 01
 * 
 */
public class Worker implements Runnable
{
	/**
	 * 业务处理类
	 */
	private Processor processor = null;

	/**
	 * 存储需要处理的通道
	 */
	private LinkedBlockingQueue<SocketChannel> queue;

	public Worker()
	{
		processor = new Processor();

		queue = new LinkedBlockingQueue<>();
	}

	/**
	 * 线程start的方法，主要是把taskQueue中的通道进行处理
	 */
	public void run()
	{
		while (true)
		{
			try
			{
				SocketChannel channel = queue.take();

				if (channel == null)
				{
					System.err.println("channel不能为空--Worker.run()");
				}

				processKey(channel);
			} catch (InterruptedException e)
			{
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
	}

	/**
	 * 负责对需要处理的通道的key进行处理
	 * 
	 * @param next
	 */
	private void processKey(SocketChannel channel)
	{
		// 以下通过processor对线程进行处理，processor就是真正负责处理的类
		processor.processRequest(channel);
	}

	/**
	 * 为该处理线程添加需要处理的channel
	 * 
	 * @param channel
	 */
	public void addChannel(SocketChannel channel)
	{
		if (channel == null)
		{
			System.err.println("channel为空--Worker.addChannel()");
		}
		queue.offer(channel);
	}
}
